package com.jojo.jojomall.search.Mythread;

import java.util.concurrent.*;

/**
 * @Author: 魔法少女小夫
 * @Data: 2022/5/18
 * @Version:
 * @Description: 异步复习测试类
 */
public class Threadtest {
    //1,继承Thread
    //2,实现runnable接口
    //3,实现callable接口
//    4.线程池创建
    public static final  ExecutorService excutor = Executors.newFixedThreadPool(10);
//    public static void main(String[] args) throws ExecutionException, InterruptedException {

//        CompletableFuture<Integer> resultre = CompletableFuture.runAsync(() -> {
//            System.out.println("当前" + Thread.currentThread().getName() + "正在执行。");
//            int i = 10 / 0;
//            System.out.println("运行结果" + i);
//        }, excutor).handle((res, thr) -> {
//            if (res != null) {
//                return 0;
//            }
//            if (thr != null) {
//                return 0;
//            }
//            return 0;
//        });
//        System.out.println(resultre.get());
//        CompletableFuture<Integer> integerCompletableFuture = CompletableFuture.supplyAsync(() -> {
//            System.out.println("当前" + Thread.currentThread().getName() + "正在执行。");
//            int i = 10 / 0;
//            System.out.println("运行结果" + i);
//            return i;
//        }).whenComplete((s,wrong)->{//相当于监听器，只能监听返回值和异常有无
//            System.out.println(Thread.currentThread().getName()+"不加async，上一步结果是这个"+s+",异常是"+wrong);
//        }).exceptionally(throwable -> {
//            System.out.println(Thread.currentThread().getName()+"exceptionally执行");
//            return 666;
//        }).whenCompleteAsync((s,wrong)->{
//            System.out.println(Thread.currentThread().getName()+"上一步和这一步都执行成功辣，上一步结果是这个"+s+",异常是"+wrong);
//        });
//        System.out.println(integerCompletableFuture.get());
        public static void main(String[] args) throws ExecutionException, InterruptedException {
            System.out.println("main----Start");
            /*这个是使用thenrun*/
//           CompletableFuture.supplyAsync(() -> {
//                System.out.println("当前" + Thread.currentThread().getName() + "正在执行。");
//                int i = 10 / 2;
//                System.out.println("运行结果" + i);
//                return i;
//            },excutor).thenRunAsync(()-> System.out.println(Thread.currentThread().getName()+"正在接着执行"),excutor);
            /*这个使用thenAccept*/  //能接受上一步结果，但无返回值
//            CompletableFuture.supplyAsync(() -> {
//                System.out.println("当前" + Thread.currentThread().getName() + "正在执行。");
//                int i = 10 / 2;
//                System.out.println("运行结果" + i);
//                return i;
//            },excutor).thenAcceptAsync(res-> System.out.println("返回值是"+res));
            CompletableFuture<String> stringCompletableFuture = CompletableFuture.supplyAsync(() -> {
                System.out.println("当前" + Thread.currentThread().getName() + "正在执行。");
                int i = 10 / 2;
                System.out.println("运行结果" + i);
                return i;
            }, excutor).thenApplyAsync((res -> res + "hello"),excutor);
            System.out.println(stringCompletableFuture.get());
            System.out.println("main----end==============");
    }




    public static void thresd()throws ExecutionException, InterruptedException {
        NewThread newThread = new NewThread();
        newThread.start();
        new Thread(()-> System.out.println("使用函数接口以及lambda方式进行创建线程"+Thread.currentThread().getName()))
                .start();
        FutureTask<Integer> integerFutureTask = new FutureTask<>(new MyCallable());
        new Thread(integerFutureTask).start();
        new Thread(new FutureTask<Integer>(new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                return 5;
            }
        })).start();
//        futureTask 可以等待异步线程结束玩获取结果 :阻塞等待，
        System.out.println("异步返回结果"+integerFutureTask.get());
//4,线程池 为了保护资源， 以上三种都不用 应该将所有的多线程异步任务都交给线程池执行；
        /*创建线程池*/
//        当前系统中池只有一两个，每一个异步任务 直接提交给线程池让他自己去执行


    }









    public static class MyCallable implements Callable<Integer>{
        @Override
        public Integer call() throws Exception {
            System.out.println("用callable+futureTask创建线程"+Thread.currentThread().getName());
            return 1;
        }
    }






    //使用继承Thread的方式来创建线程
    public static class NewThread extends Thread{
        @Override
        public void run() {
            System.out.println("使用继承Thread的方式来创建线程"+Thread.currentThread().getName());
        }
    }
}
